package com.chonry.web2.daos;

import com.chonry.web2.utils.MyMapper;
import com.chonry.web2.utils.Page;
import org.apache.ibatis.annotations.Param;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * Dao 基类
 * Created by wangys on 16/10/10.
 */
public class _BaseDao<T> {

    @Autowired
    private MyMapper<T> mapper;

    /**
     * 分页公共方法
     *
     * @param params 分页所需要的当前页/每页显示条数等参数的集合
     */
    protected Page pageHelper(Map<String, Object> params) {
        //当前页
        Integer currentPage = Integer.parseInt(params.get("currentPage") + "");

        //每页显示条数
        Integer pageSize = Integer.parseInt(params.get("pageSize") + "");

        Object start = params.get("startDate");
        Object end = params.get("endDate");

        if (start != null) {
            params.put("startDate", new Date(Long.parseLong(start + "")));
            params.put("sDate", Long.parseLong(start + ""));
        }
        if (end != null) {
            params.put("endDate", new Date(Long.parseLong(end + "")));
            params.put("eDate", Long.parseLong(end + ""));
        }

        params.put("current", currentPage > 0 ? (currentPage - 1) * pageSize : 0);
        params.put("pageSize", pageSize);

        return new Page<>(currentPage, pageSize);
    }

    /**
     * 分页查询
     * @param params
     * @return
     * @
     */
    public Page<Map<String, Object>> selectForPage(Map<String, Object> params)  {
        Page<Map<String, Object>> page = pageHelper(params);
        int count = mapper.selectCountForPage(params);
        page.setTotal(count);
        int current = (Integer) params.get("current");
        int pageSize = (Integer) params.get("pageSize");
        if(current>=count){
            params.put("current",(count-1)/pageSize*pageSize);
        }
        page.setResult(mapper.selectForPage(params));
        return page;
    }
    public List<String> queryForExport(Map<String, Object> params)  {
        Object start = params.get("startDate");
        Object end = params.get("endDate");

        if (start != null) {
            params.put("startDate", new Date(Long.parseLong(start + "")));
            params.put("sDate", Long.parseLong(start + ""));
        }
        if (end != null) {
            params.put("endDate", new Date(Long.parseLong(end + "")));
            params.put("eDate", Long.parseLong(end + ""));
        }
        return mapper.queryForExport(params);
    }
    /**
     * 查询所有
     * @param params
     * @return
     * @
     */
    public List<Map<String, Object>> selectForExport(Map<String, Object> params)  {
        return mapper.selectForPage(params);
    }

    /**---------------------------------Select---------------------------------*/

    /**
     * 根据实体中的属性值进行查询，查询条件使用等号
     *
     * @param entity
     * @return
     * @
     */
    public List<T> select(T entity)  {
        return mapper.select(entity);

    }

    /**
     * 根据主键字段进行查询，方法参数必须包含完整的主键属性，查询条件使用等号
     *
     * @param key
     * @return
     * @
     */
    public T selectByPrimaryKey(Object key)  {
        return mapper.selectByPrimaryKey(key);
    }

    /**
     * 查询全部结果，select(null)方法能达到同样的效果
     *
     * @return
     * @
     */
    public List<T> selectAll()  {
        return mapper.selectAll();
    }

    /**
     * 根据实体中的属性进行查询，只能有一个返回值，有多个结果是抛出异常，查询条件使用等号
     *
     * @param entity
     * @return
     */
    public T selectOne(T entity)  {
        return mapper.selectOne(entity);
    }

    /**
     * 根据实体中的属性查询总数，查询条件使用等号
     *
     * @param entity
     * @return
     * @
     */
    public int selectCount(T entity)  {
        return mapper.selectCount(entity);
    }

    /**
     * 根据Example条件进行查询，这个查询支持通过Example类指定查询列，通过selectProperties方法指定查询列
     *
     * @param example
     * @return
     * @
     */
    public List<T> selectByExample(Object example)  {
        return mapper.selectByExample(example);
    }

    /**
     * 根据Example条件进行查询总数
     *
     * @param example
     * @return
     * @
     */
    public int selectCountByExample(Object example)  {
        return mapper.selectCountByExample(example);
    }

    /**---------------------------------Insert---------------------------------*/

    /**
     * 保存一个实体，null的属性也会保存，不会使用数据库默认值
     *
     * @param entity
     * @return
     */
    public int insert(T entity)  {
        return mapper.insert(entity);
    }

    /**
     * 保存一个实体，null的属性不会保存，会使用数据库默认值
     *
     * @param entity
     * @return
     */
    public int insertSelective(T entity)  {
        return mapper.insertSelective(entity);
    }

    /**
     * 插入数据，限制为实体包含id属性并且必须为自增列，实体配置的主键策略无效
     *
     * @param entity
     * @return
     * @
     */
    public int insertUseGeneratedKeys(T entity)  {
        return mapper.insertUseGeneratedKeys(entity);
    }

    /**
     * 批量插入，支持批量插入的数据库可以使用，例如MySQL,H2等，另外该接口限制实体包含id属性并且必须为自增列
     *
     * @param list
     * @return
     * @
     */
    public int insertList(List<T> list)  {
        return mapper.insertList(list);
    }

    /**---------------------------------Update---------------------------------*/

    /**
     * 根据主键更新实体全部字段，null值会被更新
     *
     * @param entity
     * @return
     * @
     */
    public int updateByPrimaryKey(T entity)  {
        return mapper.updateByPrimaryKey(entity);
    }

    /**
     * 根据主键更新属性不为null的值
     *
     * @param entity
     * @return
     * @
     */
    public int updateByPrimaryKeySelective(T entity)  {
        return mapper.updateByPrimaryKeySelective(entity);
    }

    /**
     * 根据Example条件更新实体record包含的全部属性，null值会被更新
     *
     * @param record
     * @param example
     * @return
     * @
     */
    public int updateByExample(@Param("record") T record, @Param("example") Object example)  {
        return mapper.updateByExample(record, example);
    }

    /**
     * 根据Example条件更新实体record包含的不是null的属性值
     *
     * @param record  - 待删除对象
     * @param example - 条件
     * @return 行数
     * @
     */
    public int updateByExampleSelective(@Param("record") T record, @Param("example") Object example)  {
        return mapper.updateByExampleSelective(record, example);
    }

    /**---------------------------------Delete---------------------------------*/


    /**
     * 根据实体属性作为条件进行删除，查询条件使用等号
     *
     * @param record - 待删除对象
     * @return 行数
     * @
     */
    public int delete(T record)  {
        return mapper.delete(record);
    }

    /**
     * 根据主键字段进行删除，方法参数必须包含完整的主键属性
     *
     * @param key - 主键
     * @return 行数
     * @
     */
    public int deleteByPrimaryKey(Object key)  {
        return mapper.deleteByPrimaryKey(key);
    }

    /**
     * 根据Example条件删除数据
     *
     * @param example - 条件
     * @return 行数
     * @
     */
    public int deleteByExample(Object example)  {
        return mapper.deleteByExample(example);
    }
}
